package com.jsql.view.swing.table;

import com.jsql.util.LogLevelUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.swing.*;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.HashMap;
import java.util.Map;

/**
 * Class to manage the widths of columns in a table.
 *
 * Various properties control how the width of the column is calculated.
 * Another property controls whether column width calculation should be dynamic.
 * Finally, various Actions will be added to the table to allow the user
 * to customize the functionality.
 *
 * This class was designed to be used with tables that use an auto resize mode
 * of AUTO_RESIZE_OFF. With all other modes you are constrained as the width
 * of the columns must fit inside the table. So if you increase one column, one
 * or more of the other columns must decrease. Because of this the resize mode
 * of RESIZE_ALL_COLUMNS will work the best.
 */
public class AdjusterTableColumn implements PropertyChangeListener, TableModelListener {

    private static final Logger LOGGER = LogManager.getRootLogger();

    private final JTable tableAdjust;
    private final int spacing;
    private boolean isColumnHeaderIncluded;
    private boolean isColumnDataIncluded;
    private boolean isOnlyAdjustLarger;
    private boolean isDynamicAdjustment;
    private final Map<TableColumn, Integer> columnSizes = new HashMap<>();

    /**
     * Specify the table and use default spacing
     */
    public AdjusterTableColumn(JTable table) {
        this(table, 6);
    }

    /**
     * Specify the table and spacing
     */
    public AdjusterTableColumn(JTable tableAdjust, int spacing) {
        this.tableAdjust = tableAdjust;
        this.spacing = spacing;
        this.setColumnHeaderIncluded(true);
        this.setColumnDataIncluded(true);
        this.setOnlyAdjustLarger(true);
        this.setDynamicAdjustment(false);
        this.installActions();
    }

    /**
     * Adjust the widths of all the columns in the table
     */
    public void adjustColumns() {
        TableColumnModel tcm = this.tableAdjust.getColumnModel();
        for (var i = 0 ; i < tcm.getColumnCount() ; i++) {
            this.adjustColumn(i);
        }
    }

    /**
     * Adjust the width of the specified column in the table
     */
    public void adjustColumn(final int column) {
        var tableColumn = this.tableAdjust.getColumnModel().getColumn(column);
        if (!tableColumn.getResizable()) {
            return;
        }

        int columnHeaderWidth = this.getColumnHeaderWidth(column);
        int columnDataWidth   = this.getColumnDataWidth(column);
        int preferredWidth    = Math.max(columnHeaderWidth, columnDataWidth);
        this.updateTableColumn(column, preferredWidth);
    }

    /**
     * Calculated the width based on the column name
     */
    private int getColumnHeaderWidth(int column) {
        if (!this.isColumnHeaderIncluded) {
            return 0;
        }

        var tableColumn = this.tableAdjust.getColumnModel().getColumn(column);
        Object value = tableColumn.getHeaderValue();
        TableCellRenderer renderer = tableColumn.getHeaderRenderer();
        if (renderer == null) {
            renderer = this.tableAdjust.getTableHeader().getDefaultRenderer();
        }

        var c = renderer.getTableCellRendererComponent(this.tableAdjust, value, false, false, -1, column);
        return c.getPreferredSize().width;
    }

    /**
     * Calculate the width based on the widest cell renderer for the
     * given column.
     */
    private int getColumnDataWidth(int column) {
        if (!this.isColumnDataIncluded) {
            return 0;
        }

        var preferredWidth = 0;
        int maxWidth = this.tableAdjust.getColumnModel().getColumn(column).getMaxWidth();

        for (var row = 0 ; row < this.tableAdjust.getRowCount() ; row++) {
            preferredWidth = Math.max(preferredWidth, this.getCellDataWidth(row, column));
            // We've exceeded the maximum width, no need to check other rows
            if (preferredWidth >= maxWidth) {
                break;
            }
        }
        return preferredWidth;
    }

    /**
     * Get the preferred width for the specified cell
     */
    private int getCellDataWidth(int row, int column) {
        // Invoke the renderer for the cell to calculate the preferred width
        TableCellRenderer cellRenderer = this.tableAdjust.getCellRenderer(row, column);
        Component c = this.tableAdjust.prepareRenderer(cellRenderer, row, column);
        if (c != null) {  // Fix #96130: NullPointerException on c
            return c.getPreferredSize().width + this.tableAdjust.getIntercellSpacing().width;
        } else {
            LOGGER.log(LogLevelUtil.CONSOLE_JAVA, "Unexpected missing cell, data width set to 0");
            return 100;
        }
    }

    /**
     * Update the TableColumn with the newly calculated width
     */
    private void updateTableColumn(int column, int width) {
        final var tableColumn = this.tableAdjust.getColumnModel().getColumn(column);
        if (!tableColumn.getResizable()) {
            return;
        }

        int calculatedWidth = width;
        calculatedWidth += this.spacing;
        // Don't shrink the column width
        if (this.isOnlyAdjustLarger) {
            calculatedWidth = Math.max(calculatedWidth, tableColumn.getPreferredWidth());
        }

        this.columnSizes.put(tableColumn, tableColumn.getWidth());
        this.tableAdjust.getTableHeader().setResizingColumn(tableColumn);
        tableColumn.setWidth(calculatedWidth);
    }

    /**
     * Restore the widths of the columns in the table to its previous width
     */
    public void restoreColumns() {
        TableColumnModel tableColumnModel = this.tableAdjust.getColumnModel();
        for (var i = 0 ; i < tableColumnModel.getColumnCount() ; i++) {
            this.restoreColumn(i);
        }
    }

    /**
     * Restore the width of the specified column to its previous width
     */
    private void restoreColumn(int column) {
        var tableColumn = this.tableAdjust.getColumnModel().getColumn(column);
        Integer width = this.columnSizes.get(tableColumn);
        if (width != null) {
            this.tableAdjust.getTableHeader().setResizingColumn(tableColumn);
            tableColumn.setWidth(width);
        }
    }

    /**
     * Indicates whether to include the header in the width calculation
     */
    public void setColumnHeaderIncluded(boolean isColumnHeaderIncluded) {
        this.isColumnHeaderIncluded = isColumnHeaderIncluded;
    }

    /**
     * Indicates whether to include the model data in the width calculation
     */
    public void setColumnDataIncluded(boolean isColumnDataIncluded) {
        this.isColumnDataIncluded = isColumnDataIncluded;
    }

    /**
     * Indicates whether columns can only be increased in size
     */
    public void setOnlyAdjustLarger(boolean isOnlyAdjustLarger) {
        this.isOnlyAdjustLarger = isOnlyAdjustLarger;
    }

    /**
     * Indicate whether changes to the model should cause the width to be
     * dynamically recalculated.
     */
    public void setDynamicAdjustment(boolean isDynamicAdjustment) {
        // May need to add or remove the TableModelListener when changed
        if (this.isDynamicAdjustment != isDynamicAdjustment) {
            if (isDynamicAdjustment) {
                this.tableAdjust.addPropertyChangeListener(this);
                this.tableAdjust.getModel().addTableModelListener(this);
            } else {
                this.tableAdjust.removePropertyChangeListener(this);
                this.tableAdjust.getModel().removeTableModelListener(this);
            }
        }
        this.isDynamicAdjustment = isDynamicAdjustment;
    }
    
    /**
     * Implement the PropertyChangeListener
     */
    @Override
    public void propertyChange(PropertyChangeEvent e) {
        // When the TableModel changes we need to update the listeners
        // and column widths
        if ("model".equals(e.getPropertyName())) {
            TableModel model = (TableModel) e.getOldValue();
            model.removeTableModelListener(this);

            model = (TableModel) e.getNewValue();
            model.addTableModelListener(this);
            this.adjustColumns();
        }
    }
    
    /**
     * Implement the TableModelListener
     */
    @Override
    public void tableChanged(TableModelEvent e) {
        if (!this.isColumnDataIncluded) {
            return;
        }

        // A cell has been updated
        if (e.getType() == TableModelEvent.UPDATE) {
            int column = this.tableAdjust.convertColumnIndexToView(e.getColumn());

            // Only need to worry about an increase in width for this cell
            if (this.isOnlyAdjustLarger) {
                int row = e.getFirstRow();
                var tableColumn = this.tableAdjust.getColumnModel().getColumn(column);
                if (tableColumn.getResizable()) {
                    int width = this.getCellDataWidth(row, column);
                    this.updateTableColumn(column, width);
                }
            } else {
                this.adjustColumn(column);  // Could be an increase of decrease so check all rows
            }
        } else {
            this.adjustColumns();  // The update affected more than one column so adjust all columns
        }
    }

    /**
     * Install Actions to give user control of certain functionality.
     */
    private void installActions() {
        this.installColumnAction(true,  true,  "adjustColumn",   "control ADD");
        this.installColumnAction(false, true,  "adjustColumns",  "control shift ADD");
        this.installColumnAction(true,  false, "restoreColumn",  "control SUBTRACT");
        this.installColumnAction(false, false, "restoreColumns", "control shift SUBTRACT");

        this.installToggleAction(true,  false, "toggleDynamic",  "control MULTIPLY");
        this.installToggleAction(false, true,  "toggleLarger",   "control DIVIDE");
    }

    /**
     * Update the input and action maps with a new ColumnAction
     */
    private void installColumnAction(boolean isSelectedColumn, boolean isAdjust, String key, String keyStroke) {
        Action action = new ColumnAction(isSelectedColumn, isAdjust);
        var ks = KeyStroke.getKeyStroke(keyStroke);
        
        this.tableAdjust.getInputMap().put(ks, key);
        this.tableAdjust.getActionMap().put(key, action);
    }

    /**
     * Update the input and action maps with new ToggleAction
     */
    private void installToggleAction(boolean isToggleDynamic, boolean isToggleLarger, String key, String keyStroke) {
        Action action = new ToggleAction(isToggleDynamic, isToggleLarger);
        var ks = KeyStroke.getKeyStroke(keyStroke);
        
        this.tableAdjust.getInputMap().put(ks, key);
        this.tableAdjust.getActionMap().put(key, action);
    }

    /**
     * Action to adjust or restore the width of a single column or all columns
     */
    class ColumnAction extends AbstractAction {
        
        private final boolean isSelectedColumn;
        private final boolean isAdjust;

        public ColumnAction(boolean isSelectedColumn, boolean isAdjust) {
            this.isSelectedColumn = isSelectedColumn;
            this.isAdjust = isAdjust;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            // Handle selected column(s) width change actions
            if (this.isSelectedColumn) {
                int[] columns = AdjusterTableColumn.this.tableAdjust.getSelectedColumns();

                for (int column: columns) {
                    if (this.isAdjust) {
                        AdjusterTableColumn.this.adjustColumn(column);
                    } else {
                        AdjusterTableColumn.this.restoreColumn(column);
                    }
                }
            } else {
                if (this.isAdjust) {
                    AdjusterTableColumn.this.adjustColumns();
                } else {
                    AdjusterTableColumn.this.restoreColumns();
                }
            }
        }
    }

    /**
     * Toggle properties of the TableColumnAdjuster so the user can
     * customize the functionality to their preferences
     */
    class ToggleAction extends AbstractAction {
        
        private final boolean isToggleDynamic;
        private final boolean isToggleLarger;

        public ToggleAction(boolean isToggleDynamic, boolean isToggleLarger) {
            this.isToggleDynamic = isToggleDynamic;
            this.isToggleLarger = isToggleLarger;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (this.isToggleDynamic) {
                AdjusterTableColumn.this.setDynamicAdjustment(!AdjusterTableColumn.this.isDynamicAdjustment);
            } else if (this.isToggleLarger) {
                AdjusterTableColumn.this.setOnlyAdjustLarger(!AdjusterTableColumn.this.isOnlyAdjustLarger);
            }
        }
    }
}
